/**
在 TypeScript 中，类的成员修饰符用于控制类属性和方法的可见性和访问权限。
  1. 公有修饰符（public）
  - 定义： `public`  是默认的修饰符，表示该成员可以在类的内部和外部访问。
  - 使用场景：适用于希望在类的外部也能访问的属性和方法。

   示例：
  class Person {
      public name: string;

      constructor(name: string) {
          this.name = name;
      }

      public greet() {
          console.log(`Hello, my name is ${this.name}.`);
      }
  }

  const person = new Person("Alice");
  console.log(person.name); // 输出: Alice
  person.greet(); // 输出: Hello, my name is Alice.
  2. 私有修饰符（private）

  - 定义： `private`  修饰符表示该成员只能在类的内部访问，无法在类的外部访问。
  - 使用场景：适用于希望隐藏类的内部实现细节，不希望外部直接访问的属性和方法。

   示例：
  class Person {
      private age: number;

      constructor(age: number) {
          this.age = age;
      }

      public getAge() {
          return this.age; // 可以在类内部访问 private 属性
      }
  }

  const person = new Person(30);
  console.log(person.getAge()); // 输出: 30
  // console.log(person.age); // 错误: Property 'age' is private and only accessible within class 'Person'.
  3. 受保护修饰符（protected）

  - 定义： `protected`  修饰符表示该成员可以在类的内部和子类中访问，但无法在类的外部访问。
  - 使用场景：适用于希望在子类中访问父类的成员，但不希望外部直接访问的属性和方法。

   示例：
  class Person {
      protected name: string;

      constructor(name: string) {
          this.name = name;
      }
  }

  class Employee extends Person {
      private position: string;

      constructor(name: string, position: string) {
          super(name);
          this.position = position;
      }

      public introduce() {
          console.log(`Hello, my name is ${this.name} and I am a ${this.position}.`);
      }
  }

  const employee = new Employee("Bob", "Developer");
  employee.introduce(); // 输出: Hello, my name is Bob and I am a Developer.
  // console.log(employee.name); // 错误: Property 'name' is protected and only accessible within class 'Person' and its subclasses.
  4. 静态修饰符（static）

  - 定义： `static`  修饰符表示该成员属于类本身，而不是类的实例。静态成员可以通过类名直接访问。
  - 使用场景：适用于希望在类级别上共享的属性和方法。

   示例：
  class MathUtils {
      static PI: number = 3.14;

      static calculateCircumference(radius: number): number {
          return 2 * MathUtils.PI * radius;
      }
  }

  console.log(MathUtils.PI); // 输出: 3.14
  console.log(MathUtils.calculateCircumference(5)); // 输出: 31.400000000000002
  5. 结论

  在 TypeScript 中，类的成员修饰符提供了控制属性和方法访问权限的机制。通过合理使用  `public` 、 `private` 、 `protected`  和  `static`  修饰符，开发者可以实现更好的封装性和代码结构，提高代码的可维护性和可读性。在实际开发中，应根据具体需求选择合适的修饰符。
 */
class Person {
  protected name: string // 受保护的成员，只能在当前类和子类中访问
  private age: number // 私有的成员，只能在当前类中访问

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }

  // 方法变成私有方法: 只有在类内部才能访问
  private eating() {
    console.log(this.name + ' eating')
  }
}

const p = new Person('tom', 18)
// p.name = "kobe"
// p.eating()
// console.log(p.name, p.age) // 报错，私有成员只能在当前类中访问

// 子类
class Student extends Person {
  constructor(name: string, age: number) {
    super(name, age)
  }

  // 子类可以访问父类的受保护成员
  // 子类不能访问父类的私有成员
  sayHello() {
    console.log(this.name)
    // this.eating() // 报错，私有成员只能在当前类中访问
  }
}

const stu = new Student('kobe', 20)
stu.sayHello() // kobe

export {}